Motion vector based frame insertion process for increasing the frame rate of moving images

ABSTRACT

A video decoding and display system uses temporal post-processing to smooth motion in a displayed moving image. The temporal post-processing uses motion vectors each of which indicates visually similar areas in first and second frames to generate interpolated motion vectors which match areas in an interpolated frame to visually similar areas in the first and second frames. In one embodiment, each component of each motion vector is divided by two and used to generate an interpolated frame half way between the first and second frames. Display of the first and second frames are delayed so that the interpolated frame is displayed at a time half way between the display times of the first and second frames.

COPYRIGHT NOTICE

A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent files or records, but otherwise reserves all copyright rights whatsoever.

BACKGROUND OF THE INVENTION

1. Field of the Invention

This invention relates to temporal post-processing of compressed moving images and processes for improving quality of compressed moving images having low frame rates.

2. Description of Related Art

Phone lines are commonly used for digital communications between computers or other devices using modems and standard communications protocols. Such communication protocols have bit rates limited by the quality of transmission over the phone lines. For example, the V.FAST and H.26P standards for PSTN lines have bit rates between 16.8 and 28.8 kbit/s depending on the quality of the connection. These bit rates are low when compared to the bandwidth needed for transmitting high quality digital moving images, especially if the bandwidth also carries audio and/or other information.

Conventional moving images are a series of frames (or still images) which are displayed sequentially. The frames can be represented digitally by two-dimensional arrays of pixel values which indicate colors and/or intensities of pixels in the frames. Transmission of uncompressed pixel values by videophones is impractical because of the large amount of data required to transmit every pixel value in every frame of a moving picture. Accordingly, videophone systems contain encoding circuits which compress a series of two-dimensional arrays of pixel values into codes representing the moving image and decoding circuits which convert codes back into a series of two-dimensional arrays.

Frame difference coding such as DPCM (differential pulse coded modulation) is a well known compression technique that removes redundant information from a representation of a moving image. Frame difference coding subtracts pixel values of a preceding frame from pixel values of a current frame and extracts non-zero values which indicate changes between the frames. Redundant data, data repeated in successive frames, appear as zeros in the difference frame, and the large number of zeros can be efficiently coded or removed. Motion estimation techniques further reduce the number of non-zero values by subtracting from each block in a current frame, a block in a preceding frame at a position indicated by a motion vector. The motion vector is selected to reduce or minimize the difference.

Even with compression techniques, the bit rate of a communication channel limits the maximum frame rate, number of frames per second, for a moving image. For example, the H.26P standard limits video transmission to less than ten frames per second. At low frame rates, motion in displayed moving images appears jittery or discontinuous rather than smooth. Accordingly, processes for improving moving image quality at low bit rates are widely sought.

SUMMARY OF THE INVENTION

In accordance with an embodiment of the invention, a video decoding and display system uses temporal post-processing to smooth motion displayed in moving images. The temporal post-processing uses motion vectors to generate one or more interpolated frames which are inserted in the moving image. The motion vectors indicate an offset between similar areas in first and second frames. The similar areas typically contain an object that moves in the moving image. Interpolated motion vectors, which are determined from the motion vectors, indicate interpolated positions of moving objects at times between the first and second frames. One or more interpolated frames inserted between the first and second frames show the objects at the interpolated positions indicated by the interpolated motion vectors.

One embodiment of the invention, decodes and displays a moving image by: decoding first and second consecutive frames from a signal representing the moving image; generating interpolated motion vectors from motion vectors which identify blocks in the first frame which are similar to blocks in the second frame; generating one or more interpolated frames from the interpolated motion vectors; and displaying a series of frames including the first frame followed by the interpolated frames followed by the second frame. Display times of the first and second frames are delayed so that the display times of the interpolated frames are proportionally spaced between the first and second frames.

In addition to the motion vectors, information used in generating the interpolated frame includes pixel values from the first and/or second frames and/or values from difference blocks used to generate the second frame from the first frame. Typically, the motion vectors and difference blocks are decoded from a signal which represents the second frame; but alternatively, a decoder determines motion vectors from the first and second frames during post-processing.

Another embodiment of the invention is a process for forming a moving image which includes: determining a motion vector that indicates a relative offset between first and second areas of the moving image, wherein the first area in a first frame of the moving image is visually similar to the second area in a second frame of the moving image; and generating a block of interpolated pixel values from pixel values representing the first area in the first frame and pixel values representing the second area in the second frame, wherein the block of interpolated pixel values represents a third area in an interpolated frame.

Still another embodiment of the invention is a method for generating a two-dimensional array representing an interpolated frame. The method includes: filling a buffer alternatively with a dummy value or with weighted average values from a first and second frames; and generating a block of pixel values for each motion vector, wherein each generated block of pixel values is determined from the pixel values which represent a base area of a corresponding motion vector for the second frame and pixel values which represent an area of the first frame that is offset from the base area by an amount indicated by the motion vector. Each generated block of pixel values is written to the buffer at storage locations which correspond to an area which is offset from the base area by a fraction of the motion vector. The pixel values written replace some or all of the average or dummy values in the third buffer. Any remaining dummy values are replaced with pixel values that are weighted averages of corresponding pixel values from the first and second frames.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows a block diagram of a videophone system in accordance with the invention.

FIG. 2 shows a partition of a moving image into base areas.

FIG. 3 illustrates how motion vectors match areas in a current frame with similar areas in a previous frame.

FIG. 4 shows areas in an interpolated frame which match areas in a current frame.

FIG. 5 shows time lines indicating receipt and display times for frames of a moving image.

Use of the same reference symbols in different figures indicates similar or identical items.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

In accordance with an embodiment of the invention, a video decoding and display system uses temporal post-processing to provide smoother motion in moving images. The temporal post-processing uses motion vectors to generate one or more interpolated frames. The post-processing converts motion vectors which indicate visually similar areas in first and second frames to interpolated motion vectors which indicate areas in the interpolated frames which are similar to the areas in the first and second frames.

In one embodiment of the invention, each component of each motion vector is divided by two and used to generate an interpolated frame half way between the first and second frames. An area in the first frame is matched with an area in the interpolated frame half way to the visually similar base area in the second frame. Display times of the first and second frames are delayed so that the display time of the interpolated frame is half way between the display times of the first and second frames.

FIG. 1 shows an embodiment of a videophone system 100 in accordance with an embodiment of the invention. Videophone system 100 contains a video source 110, an encoder 120, a decoder 150, and a video display system 160. Video source 110 is a conventional source of a digital representation of a moving image. In the embodiment shown in FIG. 1, video source 110 includes a conventional video camera 112 which generates an analog video signal representing the moving image. An analog-to-digital converter 114 converts the analog signal into a series of two-dimensional arrays of pixel values which are stored in a frame buffer 116. Encoder 120 converts the series of two-dimensional arrays into a code representing the moving image and then transmits the code via an output channel 130 to a decoder, similar to decoder 150, in another videophone system (not shown). Channel 130 may be for example a PSTN phone line carrying an H.26P signal, but any video transmission standard may be employed.

FIGS. 2 and 3 illustrate a motion estimation process and are described in conjunction with FIG. 1. For encoding, a two-dimensional array of pixel values is partitioned into blocks B which represent base areas A11 to Anm in a current frame 200. The term base area is used herein to indicate an area which is the base of a motion vector that indicates an offset from the base area. The number of blocks (areas A11 to Anm) depends on the size of the moving image and the size of the blocks. For the H.26P standard, the moving image is 176×144 pixels and the blocks are 16×16 or 8×8 pixel values.

For each base area A11 to Anm, encoder 120 fetches a block B from frame buffer 116 and attempts to find a motion vector T and a difference block D for block B. In a first step of an encoding process, a motion estimator 127 searches the previous frame to find a block B₋₁,T which is similar block B. (As used herein, the subscript -1 indicates a block is from the previous frame, and the subscript T indicates the block corresponds to an area translated by motion vector T from the base area corresponding to block B.) Search techniques which determine motion vectors are well known in the art. For example, U.S. patent application Ser. No. 08/347,771, entitled "Motion Estimation using a Hierarchial Search" describes some search techniques and is incorporated by reference in its entirety.

In FIG. 3, pixel values of a block corresponding to an area A22 in the current frame are similar to pixel values for an area 322 in previous frame 300. Area 322 is offset from base area A22 by a motion vector 302. Similarly, a block corresponding to an area A23 is similar to a block for area 323 which is offset from base area A23 by motion vector 303.

Whether two blocks are visually similar is determined by calculating a norm of the difference between the blocks, and comparing the calculated norm to a threshold value. Common norms include the sum of the square differences or the absolute differences between corresponding pixel values in the two blocks, but other norms can be used. Blocks are similar if the calculated norm is less than the threshold value. If no similar block is found, block B is referred to as an intra block. Typically, pixel values, instead of difference blocks and motion vectors, are encoded and transmitted for intra blocks.

If a block B₋₁,T is found that is similar to block B, a predictor 126 supplies pixel values of block B₋₁,T to an adder 121. Adder 121 subtracts block B₋₁,T from block B and generates a difference block D which corresponds to block B and motion vector T. A transformer and quantizer 122 performs a conventional transformation such as a discrete cosine transform on difference block D and quantizes the results to provide symbol values representing the transformed difference block. A source coder 123 performs variable length coding, such as Huffman coding or arithmetic coding, on the symbols to reduce the number of bits required to transmit the coefficients of the transformed difference block D.

Inverse quantizer and transformer 125 and adder 124 decode the results from transformer and quantizer 122 to generate a decoded two-dimensional array for later use by predictor 126 and motion estimator 127. Motion estimator 127 transmits the motion vector T that corresponds to difference block D.

Decoder 150 receives motion vectors and coded difference blocks and generates two-dimensional arrays of pixel values which are displayed on a video display 164. For each area A11 to Anm in the current frame (also referred to below as the second frame), a source decoder 154 and an inverse quantizer and transformer 155 in decoder 150 undoes the variable length or arithmetic coding, the quantization, and transformation which were performed to encode difference block D. An adder 158 combines decoded difference block D with block B₋₁,T which a predictor 156 fetches from a buffer 151 containing a two-dimensional array of pixel values representing the previous frame (also referred to below as the first frame). Buffers 151, 152, and 153 are sets of data storage locations which may be provided in the same memory or in separate memories. To decode the second frame, adder 158 writes block B, which results from the combination of block D and B₋₁,T, to buffer 152.

In accordance with the embodiment of the invention shown in FIG. 1, an interpolator 157 generates one or more interpolated frames from pixel values in buffer 151, pixel values in buffer 152, and the motion vectors for the second frame. This is equivalent to generating interpolated frames from the first frame, the motion vectors, and difference blocks for the second frame because the first frame, the motion vectors, and the difference blocks indicate the content of the second frame.

One process for generating a two-dimensional array representing an interpolated frame first fills buffer 153 with a dummy value such as -1, and then, for each motion vector T (each block B which is not an intra block) of the second frame, generates a block B_(-x),T(x) in the interpolated frame. Index x is a fraction which depends on the number and spacing of interpolated frames between the first and second frames. For N equally spaced interpolated frames, index x is one of 1/(N+1), 2/(N+1), . . . N/(N+1). Motion vector T(x) is a vector function of x. Block B_(-x),T(x) corresponds to an area in the interpolated frame and offset by motion vector T(x) from the base area represented by block B.

Pixel values for block B_(-x),T(x) are determined by a weighted average as in equation (1).

    B.sub.-x,T(x) ={w(x)*B+ 1-w(x)!*B.sub.-1,T }               (1)

where w(x) is a weighting factor between 0 and 1, B is a block in the second frame having motion vector T, and B₋₁,T is a block in the first fame offset from block B by motion vector T. In one embodiment, motion vector T(x) is a linear function and equals the product x*T. Using linear interpolation and weighting, equation (1) is replaced with equation (2).

    B.sub.-x,x*T ={x*B+ 1-x!*B.sub.-1,T }                      (2).

In an exemplary process, one interpolated frame is inserted between the first and second frames; index x has value 1/2; and for each block B of the second frame, a block B_(-1/2),1/2T is generated according to equation (3).

    B.sub.-1/2,1/2T =(1/2*B.sub.-1,T +1/2*B)                   (3)

The remaining disclosure concentrates on the exemplary embodiment where equation (3) determines pixel values for an interpolated frame between the first and second frames. Generalizations to cases using equations (1) and (2) will be apparent in view of this disclosure.

Interpolator 157 writes pixel values generated according to equation (3) in buffer 153 at storage locations which represent the area corresponding to the block B_(-1/2),1/2T. As shown in FIG. 4, if block B corresponds to area A22, block B_(-1/2),1/2T corresponds to an area 422 which is displaced from area A22 by a motion vector 402 which is half of motion vector 302. If block B corresponds to area A23, block B_(-1/2),1/2T corresponds to area 423 which is displaced from area A23 by a motion vector 403 which is half of motion vector 303.

Equation (3) is not used on intra blocks which don't have motion vectors. If the second frame contains only a few intra blocks, the intra blocks are ignored and gaps in the two-dimensional array representing the interpolated frame are filled using a fill-in process described below. If the number of intra blocks exceeds a threshold value, the interpolated frame is set equal to the first or second frame.

Writing pixel values to buffer 153 for each interpolated block B_(-1/2),1/2T replaces dummy values which originally filled buffer 153 and previously written pixel values for other interpolated blocks. However, as illustrated by area 422 and 423, some storage locations may still contain dummy values because some areas in the interpolated frame, e.g. the gap between areas 422 and 423 and areas near intra blocks, do not correspond to any block B_(-1/2),1/2T. A fill-in process overwrites each storage location containing the dummy value with a pixel value P_(-1/2) given by equation (4).

    P.sub.-1/2 =(1/2*P.sub.-1 +1/2*P)                          (4)

where P₋₁ and P are pixel values in the first and second frames, respectively, at relative locations that are the same as the relative location of pixel value P_(-1/2) in the interpolated frame. In the general or linear cases, a fill-in pixel P_(-x) is given respectively by equation (5) or (6).

    P.sub.-x ={ 1-w(x)!*P.sub.-1 +w(x)*P}                      (5)

    P.sub.-x ={ 1-x!*P.sub.-1 +x*P}                            (6)

where w(x) is the weighting factor from equation (1).

As an alternative to initially filing buffer 153 with a dummy value and later replacing any remaining dummy values, buffer 153 can be initially filled with average values P_(-1/2) or P_(-x) as given by equations (4), (5), or (6). Generating interpolated blocks overwrites some or all of the average values and leaves the average values in the gaps between the interpolated blocks.

After generation of one or more two-dimensional arrays of pixel values representing one or more interpolated frames between the first and second frames, one or more interpolated frames between the second frame and a third transmitted frame are generated. The process is further repeated to provide a series of frames including interpolated frames between each pair of successive transmitted frames.

A video converter 162 converts the two-dimensional arrays in buffers 151, 152, and 153 into a video signal for video display 164. The video signal represents the first frame followed by one or more interpolated frames followed by the second frame. For best effect, display of the interpolated frames should be at intervals in proportion with the index x. For example, where one interpolated frame is generated for index x equal to 1/2, the interpolated frame should be displayed at a time half way between display of the first and second frames. To maintain this timing, display of the first and second frames is delayed.

FIG. 5 shows time lines for the decode and display processes of the exemplary embodiment. At times R₋₁ and R₀, decoder 150 receives the last codes representing the first and second frames, respectively. Decoding the second frame and generation of the interpolated frame proceed a block at a time substantially in parallel to minimize delay in displaying the interpolated frame. Display of the interpolated frame begins when the generation process reaches a row of blocks which are more than half the maximum motion vector below the top of the moving image. After this point, rows of pixel at the top of the interpolated frame are not changed by generating interpolated blocks.

First display of the bottom of the interpolated frame, is at time S_(-1/2), slightly after time R₀. Corresponding display times S₋₁ and S₀ for the first and second frames are separated from each other by the time between transmitted frames and are delayed relative to decoding to provide an equal time interval Δt before and after display time S_(-1/2) of the interpolated frame. The delay in displaying the second frame creates a time interval Δt before display of the last part of an interpolated frame between the second frame and a third transmitted frame. The pattern shown in FIG. 5 repeats to provide equal time intervals between interpolated and transmitted frames throughout display of the moving image.

Delaying video display can be a problem if the delay causes frames of the moving image to become noticeably out of synchronization with accompanying audio. The amount of delay depends on the frame rate and the time required to generate interpolated frames, but typically, delays for decoding and generating a single interpolated frame shift video display by less than about 200 milliseconds which is tolerable for most applications. However, the audio can also be delayed to keep video and audio in synchronization if desired.

The appendix contains a C source code listing of a procedure interpol₋₋ mid₋₋ frame which generates an interpolated frame preceding a current frame indicated by an index imv. Before procedure interpol₋₋ mid₋₋ frame starts, arrays memY₋₋ prev₋₋ f and memY₋₋ curr₋₋ f respectively contain pixel values of a previous frame and the current frame. In procedure interpol₋₋ mid₋₋ frame, a first set of nested loops, fills an array memY₋₋ mid₋₋ f with an average of the previous and current frame. Values BLK₋₋ ROWS and BLK₋₋ COLS indicate the number of blocks in a row or column of a frame. A second set of nested loops generates interpolated pixel values using the motion vectors given by an array mvect. As a result of procedure interpol₋₋ mid₋₋ frame, array memY₋₋ mid₋₋ f contains pixel values for the interpolated frame.

Although the present invention is described with reference to particular embodiments, the description is only an example of the invention's application and should not be taken as a limitation. In particular, although temporal post-processing is disclosed as applied to a videophone system, embodiments of the invention are not limited to such applications. Any moving image having a low frame rate can benefit the post-processing described. For example, the above disclosed processes can be used for displaying moving images stored at low frame rate on CD-ROM or other storage medium. Further, although processes described are most easily applied to the wide variety of compression techniques which use motion estimation, motion vectors need not be stored or transmitted with the representation of the moving image. Instead, motion vectors can be generated as part of the temporal post-processing. Various other adaptations and combinations of features of the embodiments disclosed will be apparent to those skilled in the art and are within the scope of the present invention as defined by the following claims.

                  APPENDIX                                                         ______________________________________                                         void interpol.sub.-- mid.sub.-- frame(int imv)                                 {   int i,j, m,n;                                                                  int hmvx, hmvy;                                                                int real.sub.-- row, real.sub.-- col;                                          int adj.sub.-- prev.sub.-- x, adj.sub.-- prev.sub.-- y;                        int adj.sub.-- curr.sub.-- x, adj.sub.-- curr.sub.-- y;                        for(i=0; i<BLK.sub.-- ROWS; i++)                                           for (j=0; j<BLK.sub.-- COLS; j++)                                              for (m=0; m<16; m++)                                                           for (n=0; n<16; n++)                                                           {       real.sub.-- row = 16*i + m;                                                    real.sub.-- col = 16*j + n;                                                    memY.sub.-- mid.sub.-- f real.sub.-- row! real.sub.-- col! =                  (memY.sub.-- prev.sub.-- f real.sub.-- row! real.sub.-- col! +                 memY.sub.-- curr.sub.-- f real.sub.-- row! real.sub.-- col!)/2;         for(i=0; i<BLK.sub.-- ROWS; i++)                                               for (j=0; j<BLK.sub.-- COLS; j++)                                              {      hmvx = (int) (mvect imv! i! j!·x/2);                                  hmvy = (int) (mvect imv! i! j!·y/2);                                  for (m=0; m<16; m++)                                                    for (n=0; n<16; n++)                                                           {        real.sub.-- row = 16*i + m;                                                    real.sub.-- col = 16*j + n;                                                    adj.sub.-- prev.sub.-- x = real.sub.-- col + hmvx;                             adj.sub.-- prev.sub.-- y = real.sub.-- row + hmvy;                             adj.sub.-- curr.sub.-- x = real.sub.-- col + 2*hmvx;                           adj.sub.-- curr.sub.-- y = real.sub.-- row + 2*hmvy;                  memY.sub.-- mid.sub.-- f adj.sub.-- prev.sub.-- y! adj.sub.-- prev.sub.--      x! =                                                                                  (memY.sub.-- prev.sub.-- f adj.sub.-- curr.sub.-- y! adj.sub.--                curr.sub.-- x!                                                                 + memY.sub.-- curr.sub.-- f real.sub.-- row! real.sub.-- col!)/2;       }                                                                               }                                                                             }                                                                              ______________________________________                                     

I claim:
 1. A real-time post-processing method for display of a moving image, comprising:decoding a coded signal to generate a first two-dimensional array of pixel values which represent a first frame of the moving image; decoding the coded signal to generate a second two-dimensional array of pixel values representing a second frame of the moving image, wherein decoding the coded signal includes decoding code values which indicate motion vectors for the second frame, each motion vector corresponding to a different base area in the moving image and indicating an offset to an area of the first frame which is similar to the base area of the second frame; interpolating the motion vectors to generate interpolated motion vectors; generating a third two-dimensional array of pixel values using the interpolated motion vectors, the first two-dimensional array, and the second two-dimensional array, wherein the third two-dimensional array represents an interpolated frame; displaying the first frame as represented by the first two-dimensional array; displaying the interpolated frame as represented by the third two-dimensional array, after displaying the first frame; and displaying the second frame as represented by the second two-dimensional array, after displaying the interpolated frame, wherein generating a third two-dimensional array comprises: filling a buffer with a dummy value; generating a block of pixel values for each motion vector, wherein the generated block of pixel values for each motion vector is determined from the pixel values in the second array that represent the base area of the motion vector and from pixel values in the first array that represent an area offset from the base area by an amount indicated by the motion vector; writing each generated block of pixel values to the buffer at storage locations that correspond to an area that is offset from the base area by an interpolated motion vector that is a fraction of the motion vector; and after writing the generated blocks of pixel values, replacing each dummy value remaining in the buffer with a pixel value that is a weighted average of a corresponding pixel value in the first array and a corresponding pixel value in the second array.
 2. The method of claim 1, further comprising transmitting the coded signal to a decoder which decodes the coded signal and generates the pixel values in the first, second, and third arrays.
 3. The process of claim 2, further comprising:decoding a signal transmitted to the decoder to determine difference blocks; and generating the second two-dimensional array from the first two-dimensional array, the motion vectors, and the difference blocks. 